home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / oper_sys / deltablu / usflcnst.c < prev    next >
C/C++ Source or Header  |  1993-08-17  |  4KB  |  185 lines
  1. /***************************************************************************
  2.  UsefulConstraints.c
  3.  
  4.     Some useful constraints.
  5.  
  6. ****************************************************************************/
  7.  
  8. #include <stdio.h>
  9. #include "List.h"
  10. #include "Constraints.h"
  11. #include "DeltaBlue.h"
  12. #include "UsefulConstraints.h"
  13.  
  14. /* macro to reference a constraint variable value */
  15. #define var(i) ((c->variables[i])->value)
  16.  
  17. /******* Stay Constraint *******/
  18.  
  19. Constraint StayC(v, strength)
  20. Variable v;
  21. int strength;
  22. {
  23.     Constraint new = Constraint_Create(1, strength);
  24.     new->variables[0] = v;
  25.     new->methodCount = 1;
  26.     new->methodOuts[0] = 0;
  27.     AddConstraint(new);
  28.     return new;
  29. };
  30.  
  31. /******* Edit Constraint *******/
  32.  
  33. Constraint EditC(v, strength)
  34. Variable v;
  35. int strength;
  36. {
  37.     Constraint new = Constraint_Create(1, strength);
  38.     new->inputFlag = true;
  39.     new->variables[0] = v;
  40.     new->methodCount = 1;
  41.     new->methodOuts[0] = 0;
  42.     AddConstraint(new);
  43.     return new;
  44. };
  45.  
  46. /****** Equals Constraint ******/
  47.  
  48. void EqualsC_Execute(Constraint);
  49. static void EqualsC_Execute(c)
  50. register Constraint c;
  51. {
  52.     /* a = b */
  53.    switch (c->whichMethod) {
  54.     case 0:
  55.     var(0) = var(1);
  56.     break;
  57.     case 1:
  58.     var(1) = var(0);
  59.     break;
  60.     }
  61. }
  62.  
  63. Constraint EqualsC(a, b, strength)
  64. Variable a, b;
  65. int strength;
  66. {
  67.     Constraint new = Constraint_Create(2, strength);
  68.     new->execute = EqualsC_Execute;
  69.     new->variables[0] = a;
  70.     new->variables[1] = b;
  71.     new->methodCount = 2;
  72.     new->methodOuts[0] = 0;
  73.     new->methodOuts[1] = 1;
  74.     AddConstraint(new);
  75.     return new;
  76. };
  77.  
  78. /******** Add Constraint *******/
  79.  
  80. void AddC_Execute(Constraint);
  81. static void AddC_Execute(c)
  82. register Constraint c;
  83. {
  84.     /* a + b = sum */
  85.     switch (c->whichMethod) {
  86.     case 0:
  87.     var(2) = var(0) + var(1);
  88.     break;
  89.     case 1:
  90.     var(1) = var(2) - var(0);
  91.     break;
  92.     case 2:
  93.     var(0) = var(2) - var(1);
  94.     break;
  95.     }
  96. }
  97.  
  98. Constraint AddC(a, b, sum, strength)
  99. Variable a, b, sum;
  100. int strength;
  101. {
  102.     Constraint new = Constraint_Create(3, strength);
  103.     new->execute = AddC_Execute;
  104.     new->variables[0] = a;
  105.     new->variables[1] = b;
  106.     new->variables[2] = sum;
  107.     new->methodCount = 3;
  108.     new->methodOuts[0] = 2;
  109.     new->methodOuts[1] = 1;
  110.     new->methodOuts[2] = 0;
  111.     AddConstraint(new);
  112.     return new;
  113. };
  114.  
  115. /******** Multiply Constraint *******/
  116.  
  117. void MultiplyC_Execute(Constraint);
  118. static void MultiplyC_Execute(c)
  119. register Constraint c;
  120. {
  121.     /* a * b = prod */
  122.     switch (c->whichMethod) {
  123.     case 0:
  124.     var(2) = var(0) * var(1);
  125.     break;
  126.     case 1:
  127.     var(1) = var(2) / var(0);
  128.     break;
  129.     case 2:
  130.     var(0) = var(2) / var(1);
  131.     break;
  132.     }
  133. }
  134.  
  135. Constraint MultiplyC(a, b, prod, strength)
  136. Variable a, b, prod;
  137. int strength;
  138. {
  139.     Constraint new = Constraint_Create(3, strength);
  140.     new->execute = MultiplyC_Execute;
  141.     new->variables[0] = a;
  142.     new->variables[1] = b;
  143.     new->variables[2] = prod;
  144.     new->methodCount = 3;
  145.     new->methodOuts[0] = 2;
  146.     new->methodOuts[1] = 1;
  147.     new->methodOuts[2] = 0;
  148.     AddConstraint(new);
  149.     return new;
  150. };
  151.  
  152. /******** ScaleOffset Constraint *******/
  153.  
  154. void ScaleOffsetC_Execute(Constraint);
  155. static void ScaleOffsetC_Execute(c)
  156. register Constraint c;
  157. {
  158.     /* (src * scale) + offset = dest */
  159.     switch (c->whichMethod) {
  160.     case 0:
  161.     var(3) = (var(0) * var(1)) + var(2);
  162.     break;
  163.     case 1:
  164.     var(0) = (var(3) - var(2)) / var(1);
  165.     break;
  166.     }
  167. }
  168.  
  169. Constraint ScaleOffsetC(src, scale, offset, dest, strength)
  170. Variable src, scale, offset, dest;
  171. int strength;
  172. {
  173.     Constraint new = Constraint_Create(4, strength);
  174.     new->execute = ScaleOffsetC_Execute;
  175.     new->variables[0] = src;
  176.     new->variables[1] = scale;
  177.     new->variables[2] = offset;
  178.     new->variables[3] = dest;
  179.     new->methodCount = 2;
  180.     new->methodOuts[0] = 3;
  181.     new->methodOuts[1] = 0;
  182.     AddConstraint(new);
  183.     return new;
  184. };
  185.